feat: register Discord command groups - #9445

Please address the comments from this code review:

## Individual Comments

### Comment 1
<location path="astrbot/core/platform/sources/discord/discord_platform_adapter.py" line_range="565" />
<code_context>
+        Returns:
+            Whether the name can be registered with Discord.
+        """
+        return name == name.lower() and bool(re.match(r"^[-_'\w]{1,32}$", name))
+
+    @staticmethod
</code_context>
<issue_to_address>
**issue (bug_risk):** Slash command name validator allows characters Discord likely rejects (single quote), causing potential registration failures.

The regex `^[-_'\w]{1,32}$` currently allows single quotes, but Discord’s documented pattern only permits lowercase letters, digits, underscores, and hyphens (e.g. `^[a-z0-9_-]{1,32}$` or `^[\w-]{1,32}$` with the existing lowercase check). This mismatch means we may accept command names that Discord rejects with 400s at registration. Please align the regex with Discord’s constraints so invalid names are caught locally.
</issue_to_address>

### Comment 2
<location path="astrbot/core/platform/sources/discord/discord_platform_adapter.py" line_range="627" />
<code_context>
+            parent=parent,
+        )
+
+    def _create_slash_command_group(
+        self,
+        group_filter: CommandGroupFilter,
</code_context>
<issue_to_address>
**issue (complexity):** Consider further refactoring `_create_slash_command_group` by extracting small helpers for path formatting, option limits, and name validation to flatten control flow and reduce duplication.

The new helpers already reduce some duplication, but `_create_slash_command_group` still has tightly nested control flow and repeated validation/logging logic. You can simplify it further with small utilities without changing behavior.

### 1. Centralize command path formatting

Right now the command path is inlined multiple times:

```py
f"{root_name} {child_name}"
f"{root_name} {child_name} {leaf_name}"
```

Introduce a tiny formatter and use it everywhere:

```py
@staticmethod
def _format_command_path(*parts: str) -> str:
    return " ".join(parts)
```

Then update your uses:

```py
path = self._format_command_path(root_name, child_name)
logger.warning(
    f"[Discord] Skipping invalid or duplicate entry '{path}'."
)

leaf_path = self._format_command_path(root_name, child_name, leaf_name)
logger.warning(
    f"[Discord] Skipping invalid or duplicate entry '{leaf_path}'."
)
```

This reduces noise and makes intent clearer.

### 2. Extract option‑limit checks into a helper

The `_DISCORD_MAX_OPTIONS` limit and related logging is duplicated for root group and subgroup. You can centralize this:

```py
def _can_add_option(
    self,
    group: discord.SlashCommandGroup,
    path: str,
) -> bool:
    if len(group.subcommands) >= _DISCORD_MAX_OPTIONS:
        logger.warning(
            f"[Discord] Command group '{path}' exceeds "
            f"{_DISCORD_MAX_OPTIONS} options; remaining entries were skipped."
        )
        return False
    return True
```

Use it in both loops:

```py
for child_filter in group_filter.sub_command_filters:
    if not self._can_add_option(root_group, root_name):
        break
    ...

for leaf_filter in child_filter.sub_command_filters:
    subgroup_path = self._format_command_path(root_name, child_name)
    if not self._can_add_option(subgroup, subgroup_path):
        break
    ...
```

Now both limit checks share the same behavior and wording.

### 3. Extract shared name/duplicate validation

You have similar logic for root vs subgroup:

```py
if (
    not self._is_valid_slash_command_name(child_name)
    or child_name in root_names
):
    ...
if (
    not self._is_valid_slash_command_name(leaf_name)
    or leaf_name in subgroup_names
):
    ...
```

This can be consolidated into a small helper that also handles logging:

```py
def _is_valid_unique_name(
    self,
    name: str,
    used: set[str],
    path: str,
) -> bool:
    if not self._is_valid_slash_command_name(name) or name in used:
        logger.warning(
            f"[Discord] Skipping invalid or duplicate entry '{path}'."
        )
        return False
    return True
```

Then the loops become flatter:

```py
child_path = self._format_command_path(root_name, child_name)
if not self._is_valid_unique_name(child_name, root_names, child_path):
    continue

...

leaf_path = self._format_command_path(root_name, child_name, leaf_name)
if not self._is_valid_unique_name(leaf_name, subgroup_names, leaf_path):
    continue
```

This pulls validation and logging out of the nested control flow, making `_create_slash_command_group` easier to read while preserving all behavior.
</issue_to_address>